#include "head.h"
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <arpa/inet.h>
#include <pthread.h>
#include "MQTTClient.h"
#include <sys/wait.h>
#include <errno.h>
#include <signal.h>
#include <pthread.h>
#include <semaphore.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/epoll.h>

#define ADDRESS "tcp://192.168.250.100:1883"
#define CLIENTID "ExampleClientPub"
#define TOPIC_FLAG "MQTT Flag"
#define TOPIC_COUNT "MQTT Count"
#define QOS 1          // 服务质量
#define TIMEOUT 10000L // 超时时长

#define IP "192.168.250.100"
#define PORT 6666

typedef struct 
{
    int people_flag;  // 有人标志
    int people_count; // 人数 
}peo_t;
peo_t peo;

// 创建epoll事件集合
struct epoll_event event; // 用于操作epoll
struct epoll_event events[64] = {0};

int socket_init()
{
    //(1).创建流式套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sfd < 0)
    {
        ERR_MSG("socket");
        return -1;
    }

    // 填充服务器的地址信息结构体，给bind函数绑定
    // 真实的地址信息结构体根据地址族制定：AF_INET:man 7 ip

    struct sockaddr_in sin;
    sin.sin_family = AF_INET;            // 必须填AF_INET
    sin.sin_port = htons(PORT);          // 端口号 网络字节序
    sin.sin_addr.s_addr = inet_addr(IP); // IP     网络字节序

    //(2).绑定服务器的ip和端口 （必须绑定）
    if (bind(sfd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
    {
        ERR_MSG("bind");
        return -1;
    }
    printf("bind success __%d__\n", __LINE__);

    //(3).将套接字设置为被动监听状态
    if (listen(sfd, 128) < 0)
    {
        ERR_MSG("listen");
        return -1;
    }
    printf("listen success __%d__\n", __LINE__);
    int reuse = 1;
    if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0)
    {
        ERR_MSG("setsockopt");
        return -1;
    }
    printf("允许端口快速被重用成功\n");
    //(4).返回创建的服务器套接字
    return sfd;
}
// 2.创建epoll，并且初始化
int epoll_init(int sfd)
{
    // 创建epoll句柄
    int epfd = epoll_create(1);
    if (epfd < 0)
    {
        printf("epoll_create filed\n");
        return -1;
    }

    // 添加服务器事件
    event.events = EPOLLIN; // 读事件
    event.data.fd = sfd;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, sfd, &event) < 0)
    {
        printf("epoll_ctl add filed\n");
        return -1;
    }

    return epfd;

    // 返回一个epfd容器里面有一个sfd向外监听
}

// 3.监控客户端连接
int client_connect(int sfd, int epfd)
{
    // 服务器内存放客户端的容器
    struct sockaddr_in cin;
    socklen_t addrlen = sizeof(cin);

    int count;       // 触发文件描述符个数
    int newfd = -1;  // 接受新连接的客户端文件描述符fd
    ssize_t res = 0; // recv的返回值

    while (1)
    {
        // wait来监听谁需要链接或发送数据至服务器
        count = epoll_wait(epfd, events, sizeof(events), -1);
        if (count < 0)
        {
            ERR_MSG("epoll_wait");
            return -1;
        }
        printf("成功触发事件的文件描述符个数=%d\n", count);

        // for循环遍历监控表
        for (int i = 0; i < count; i++)
        {
            // 遍历fd来判断是连接还是发送数据
            if (events[i].data.fd == sfd)
            {

                fprintf(stdout, "触发服务器连接事件>>>");
                fflush(stdout);
                putchar(10);

                // 获取连接成功后的新套接字文件描述符
                newfd = accept(sfd, (struct sockaddr *)&cin, &addrlen);
                if (newfd < 0)
                {
                    ERR_MSG("accept");
                    return -1;
                }
                printf("[%s:%d]客户端连接成功,\tnewfd=%d,__%d__\n\n",
                       inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), newfd, __LINE__);

                // 添加新连接的客户端文件描述符到epoll集合中
                event.events = EPOLLIN; // 读事件 EPOLLOUT:写事件
                event.data.fd = newfd;
                if (epoll_ctl(epfd, EPOLL_CTL_ADD, newfd, &event) < 0)
                {
                    ERR_MSG("client newfd");
                    return -1;
                }

                printf("打印传入标志=%d", peo.people_flag);
                send(newfd, &peo, sizeof(peo_t), 0);
            }
            // 不是fd不等于sfd  则是交互事件
            else
            {
                res = recv(events[i].data.fd, &peo, sizeof(peo), 0);
                printf("收收收人数=%d", peo.people_count);
                printf("触发服务器交互事件>>>\n");

                // 接收失败
                if (res < 0)
                {
                    ERR_MSG("recv");
                    return -1;
                }
                else if (res == 0)
                {

                    printf("[%s:%d]客户端下线,newfd=%d,__%d__\n\n",
                           inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), events[i].data.fd, __LINE__);

                    // 清除文件描述符
                    if (epoll_ctl(epfd, EPOLL_CTL_DEL, events[i].data.fd, &event) < 0)
                    {
                        ERR_MSG("delete useless client fd");
                    }
                    //  关闭无效客户端文件描述符
                    close(events[i].data.fd);
                    continue;
                }

                // while (1)
                // {
                    
                    //sleep(1);
                // }
            }
        }
    }
}

// 通过TCP将数据发到QT
void *server(void *arg)
// void sent_to_qt_tcp(const char *data)
{
    // 1.套接字初始化
    int sfd = socket_init();

    // 2.创建epoll，并且初始化
    int epfd = epoll_init(sfd);

    // 3.监控客户端连接
    client_connect(sfd, epfd);

    // while(1);

    // 关闭套接字文件描述
    close(sfd);

    pthread_exit(NULL);

    return (void *)0;
}

// 定义一个用于表示发布消息的令牌，并使其具有易变性
volatile MQTTClient_deliveryToken deliveredtoken;

// 定义一个消息投递回调函数，用于提示消息是否成功投递
void delivered(void *context, MQTTClient_deliveryToken dt)
{
    printf("已确认令牌值%d消息的传递\n", dt);
    deliveredtoken = dt;
}

// 定义一个消息到达回调函数，用于处理接收到的消息
int msgarrvd(void *context, char *topicName, int topicLen, MQTTClient_message *message)
{
    int i;
    char *payloadptr;

    printf("收到消息\n");
    printf("   主题: %s\n", topicName);
    printf("   消息: ");

    payloadptr = message->payload;
    for (i = 0; i < message->payloadlen; i++)
    {
        putchar(*payloadptr++);
    }
    putchar('\n');
    // 接收人数到people_flag
    sscanf(message->payload, "%d", &peo.people_flag);
    printf("peo.people_flag=%d\n", peo.people_flag);
    MQTTClient_freeMessage(&message);
    MQTTClient_free(topicName);
    return 1;
}
// 定义一个连接丢失回调函数，用于处理连接丢失情况
void connlost(void *context, char *cause)
{
    printf("\n连接丢失\n");
    printf("     原因: %s\n", cause);
}

int main(int argc, char *argv[])
{
    pthread_t tid;
    if (pthread_create(&tid, NULL, server, NULL) != 0)
    {
        fprintf(stderr, "pthread_create fail__%d__\n", __LINE__);
        return -1;
    }

    // 1 创建了MQTTClient对象
    MQTTClient client;
    // 3初始化连接选项
    MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
    MQTTClient_message pubmsg = MQTTClient_message_initializer; // 发布消息
    MQTTClient_deliveryToken token;                             // 令牌
    int rc;
    int ch;
    // 2 使用指定的地址和客户端 ID 创建 MQTT 客户端
    MQTTClient_create(&client, ADDRESS, CLIENTID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
    // 3 初始化连接选项，并设置保活时间和清除会话标志
    conn_opts.keepAliveInterval = 20;
    conn_opts.cleansession = 1;

    // 4设置 MQTT 客户端回调函数 丢失回调 消息到达回调 消息投递回调
    MQTTClient_setCallbacks(client, NULL, connlost, msgarrvd, delivered);

    // 5连接到 MQTT 服务器
    if ((rc = MQTTClient_connect(client, &conn_opts)) != MQTTCLIENT_SUCCESS)
    {
        printf("连接MQTT服务器失败, return code %d\n", rc);
        exit(EXIT_FAILURE);
    }
    printf("订阅主题：%s\n 客户端ID：%s 服务质量%d\n\n"
           "Press Q<Enter> to quit\n\n",
           TOPIC_FLAG, CLIENTID, QOS);
    // 6订阅指定的主题
    MQTTClient_subscribe(client, TOPIC_FLAG, QOS);

    char payload[128] = "";
    while (1)
    {
        // 1 设置发布消息的内容、长度、QoS 等级和保留标志
        sprintf(payload, "%d", peo.people_count);
        pubmsg.payload = payload;
        pubmsg.payloadlen = (int)strlen(payload);
        pubmsg.qos = QOS;
        pubmsg.retained = 0;
        // 2 发布消息到指定的主题，并获取传递令牌
        MQTTClient_publishMessage(client, TOPIC_COUNT, &pubmsg, &token);
        printf("等待 %d 秒 发送内容：%s\n"
               "主题：%s 客户端ID：%s\n",
               (int)(TIMEOUT / 1000), (char *)pubmsg.payload, TOPIC_COUNT, CLIENTID);
        // 3 等待指定时间，直到消息传递完成，并获取结果
        rc = MQTTClient_waitForCompletion(client, token, TIMEOUT);
        printf("传递了传递令牌（%d）的消息\n\n", token);

        usleep(2000000); // 5 秒钟发送一次数据
    }

    MQTTClient_unsubscribe(client, TOPIC_FLAG); // 7订阅指定的主题
    MQTTClient_disconnect(client, 10000);       // 8断开 MQTT 客户端与服务器的连接，超时时间为 10 秒
    MQTTClient_destroy(&client);                // 9销毁 MQTT 客户端实例

    pthread_join(tid, NULL);
    return rc;
}
